package com.zjx.mhxykey.util;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.util.Base64;
import android.util.Log;

import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;

/**
 * Bitmap与String转换工具类
 * 提供多种Bitmap与String相互转换的方法，包括Base64编码、二进制字符串和文件路径方式
 */
public class BitmapStringConverter {
    private static final String TAG = "BitmapStringConverter";

    /**
     * 将Bitmap转换为Base64编码的字符串
     *
     * @param bitmap 要转换的Bitmap对象
     * @param format 压缩格式（Bitmap.CompressFormat.PNG/JPEG/WEBP）
     * @param quality 压缩质量（0-100），仅对JPEG和WEBP有效
     * @return Base64编码的字符串，如果bitmap为null则返回null
     */
    public static String bitmapToBase64(Bitmap bitmap, Bitmap.CompressFormat format, int quality) {
        if (bitmap == null) {
            Log.w(TAG, "bitmapToBase64: 输入的bitmap为null");
            return null;
        }

        ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
        bitmap.compress(format, quality, byteArrayOutputStream);
        byte[] byteArray = byteArrayOutputStream.toByteArray();
        return Base64.encodeToString(byteArray, Base64.DEFAULT);
    }

    /**
     * 将Base64字符串解码为Bitmap
     *
     * @param encodedString Base64编码的图片字符串
     * @return 解码后的Bitmap对象，如果输入为null或解码失败则返回null
     */
    public static Bitmap base64ToBitmap(String encodedString) {
        if (encodedString == null || encodedString.isEmpty()) {
            Log.w(TAG, "base64ToBitmap: 输入的字符串为null或空");
            return null;
        }

        try {
            byte[] decodedBytes = Base64.decode(encodedString, Base64.DEFAULT);
            return BitmapFactory.decodeByteArray(decodedBytes, 0, decodedBytes.length);
        } catch (IllegalArgumentException e) {
            Log.e(TAG, "base64ToBitmap: Base64解码失败", e);
            return null;
        }
    }

    /**
     * 将Bitmap保存到缓存文件并返回文件路径
     *
     * @param context 上下文对象
     * @param bitmap 要保存的Bitmap
     * @param filename 保存的文件名（不含路径）
     * @param format 压缩格式
     * @param quality 压缩质量（0-100）
     * @return 保存的文件绝对路径，如果失败则返回null
     */
    public static String bitmapToFile(Context context, Bitmap bitmap, String filename,
                                      Bitmap.CompressFormat format, int quality) {
        if (bitmap == null || context == null) {
            Log.w(TAG, "bitmapToFile: 输入参数为null");
            return null;
        }

        File cacheDir = context.getCacheDir();
        File imageFile = new File(cacheDir, filename);

        try (FileOutputStream out = new FileOutputStream(imageFile)) {
            bitmap.compress(format, quality, out);
            return imageFile.getAbsolutePath();
        } catch (IOException e) {
            Log.e(TAG, "bitmapToFile: 保存文件失败", e);
            return null;
        }
    }

    /**
     * 从文件路径加载Bitmap
     *
     * @param filePath 图片文件绝对路径
     * @param reqWidth 目标宽度（像素），如果<=0则不缩放
     * @param reqHeight 目标高度（像素），如果<=0则不缩放
     * @return 加载的Bitmap对象，如果失败则返回null
     */
    public static Bitmap fileToBitmap(String filePath, int reqWidth, int reqHeight) {
        if (filePath == null || filePath.isEmpty()) {
            Log.w(TAG, "fileToBitmap: 文件路径为null或空");
            return null;
        }

        // 如果不需要缩放，直接加载
        if (reqWidth <= 0 || reqHeight <= 0) {
            return BitmapFactory.decodeFile(filePath);
        }

        // 先只解码边界信息
        BitmapFactory.Options options = new BitmapFactory.Options();
        options.inJustDecodeBounds = true;
        BitmapFactory.decodeFile(filePath, options);

        // 计算采样率
        options.inSampleSize = calculateInSampleSize(options, reqWidth, reqHeight);

        // 真正解码Bitmap
        options.inJustDecodeBounds = false;
        return BitmapFactory.decodeFile(filePath, options);
    }

    /**
     * 计算Bitmap采样率
     *
     * @param options 包含原始图片尺寸的Options对象
     * @param reqWidth 目标宽度
     * @param reqHeight 目标高度
     * @return 合适的采样率（2的幂）
     */
    private static int calculateInSampleSize(BitmapFactory.Options options, int reqWidth, int reqHeight) {
        final int height = options.outHeight;
        final int width = options.outWidth;
        int inSampleSize = 1;

        if (height > reqHeight || width > reqWidth) {
            final int halfHeight = height / 2;
            final int halfWidth = width / 2;

            while ((halfHeight / inSampleSize) >= reqHeight
                    && (halfWidth / inSampleSize) >= reqWidth) {
                inSampleSize *= 2;
            }
        }

        return inSampleSize;
    }

    /**
     * 将Bitmap转换为十六进制字符串（性能较低，不推荐大量数据使用）
     *
     * @param bitmap 要转换的Bitmap
     * @return 十六进制字符串，如果bitmap为null则返回null
     */
    public static String bitmapToHexString(Bitmap bitmap) {
        if (bitmap == null) {
            Log.w(TAG, "bitmapToHexString: 输入的bitmap为null");
            return null;
        }

        ByteArrayOutputStream stream = new ByteArrayOutputStream();
        bitmap.compress(Bitmap.CompressFormat.PNG, 100, stream);
        byte[] byteArray = stream.toByteArray();

        StringBuilder sb = new StringBuilder();
        for (byte b : byteArray) {
            sb.append(String.format("%02X", b));
        }
        return sb.toString();
    }

    /**
     * 将十六进制字符串转换为Bitmap（性能较低，不推荐大量数据使用）
     *
     * @param hexString 十六进制字符串
     * @return 转换后的Bitmap，如果输入为null或转换失败则返回null
     */
    public static Bitmap hexStringToBitmap(String hexString) {
        if (hexString == null || hexString.isEmpty()) {
            Log.w(TAG, "hexStringToBitmap: 输入的字符串为null或空");
            return null;
        }

        try {
            int len = hexString.length();
            byte[] data = new byte[len / 2];
            for (int i = 0; i < len; i += 2) {
                data[i / 2] = (byte) ((Character.digit(hexString.charAt(i), 16) << 4)
                        + Character.digit(hexString.charAt(i + 1), 16));
            }
            return BitmapFactory.decodeByteArray(data, 0, data.length);
        } catch (Exception e) {
            Log.e(TAG, "hexStringToBitmap: 转换失败", e);
            return null;
        }
    }

    public static void main(String[] args) {
        Bitmap bitmap = null;
        Context context = null;
        // 1. Base64编码转换
        String base64String = BitmapStringConverter.bitmapToBase64(bitmap, Bitmap.CompressFormat.JPEG, 80);
        Bitmap restoredBitmap = BitmapStringConverter.base64ToBitmap(base64String);

// 2. 文件路径方式
        String filePath = BitmapStringConverter.bitmapToFile(context, bitmap, "temp.jpg",
                Bitmap.CompressFormat.JPEG, 90);
        Bitmap fromFile = BitmapStringConverter.fileToBitmap(filePath, 200, 200); // 缩放到200x200

// 3. 十六进制字符串（不推荐大量数据使用）
        String hexString = BitmapStringConverter.bitmapToHexString(bitmap);
        Bitmap fromHex = BitmapStringConverter.hexStringToBitmap(hexString);
    }
}